home *** CD-ROM | disk | FTP | other *** search
/ Group 42-Sells Out! - The Information Archive / Group 42 Sells Out (Group 42) (1996).iso / crypto / shs_doc.txt < prev    next >
Internet Message Format  |  1995-11-30  |  25KB
  1. From:  Dennis Branstad, NIST Fellow
  2.  
  3.      On January 31, 1992, NIST published in the Federal Register a proposed
  4. Secure Hash Standard (SHS) designed to work with the proposed Digital
  5. Signature Standard (DSS).  I am taking the liberty to send you an electronic
  6. copy of the proposed standard's announcement section, technical
  7. specifications and appendix A.  Because of mail limitations, I left off
  8. appendix B which is just a second example and the federal register
  9. solication for comments.  Miles Smid is the point of contact for comments
  10. which are due in 90 days.  The following is the core of the proposed
  11. standard.  Note that the name implies only that the algorithm, to the best
  12. of our knowledge, exhibits the qualities needed for a hashing algorithm
  13. acceptable to work with the DSS.  Also note the credit to Ron Rivest.
  14.  
  15.  
  16.                    SECURE HASH STANDARD (SHS)
  17.  
  18.  
  19.                                Abstract
  20.  
  21.    This standard specifies a Secure Hash Algorithm (SHA) which can
  22. be used to generate a message digest for a message.  A message
  23. digest is a condensed version of the original message.  This
  24. algorithm can be used with the Digital Signature Standard (DSS). 
  25.  
  26. Key words: ADP security, computer security, digital signatures,
  27. Federal Information Processing Standard, hash algorithm.
  28.  
  29. Name of Standard: Secure Hash Standard.
  30.  
  31. Category of Standard: ADP Operations, Computer Security.
  32.  
  33. Explanation: This Standard specifies a Secure Hash Algorithm (SHA),
  34. which is necessary to ensure the security of the Digital Signature
  35. Algorithm (DSA). When a message of any length < 2^64 bits is input,
  36. the SHA produces a 160-bit output called a message digest.  The
  37. message digest is then input to the DSA which computes the
  38. signature for the message.  Signing the message digest rather than
  39. the message often improves the efficiency of the process, because
  40. the message digest is usually much smaller than the message.  The
  41. same message digest should be obtained by the verifier of the
  42. signature when the received version of the message is used as input
  43. to the SHA.  The SHA is called secure because it is designed to be
  44. computationally infeasible to recover a message corresponding to a
  45. given message digest, or to find two different messages which
  46. produce the same message digest.  Any change to a message in
  47. transit will, with very high probability, result in a different
  48. message digest, and the signature will fail to verify.  The SHA is
  49. based on principles similar to those used by Professor Ronald L. Rivest
  50. of MIT when designing the MD4 hash algorithm ("The MD4 Message Digest 
  51. Algorithm," Advances in Cryptology - CRYPTO '90 Proceedings, 
  52. Springer-Verlag, 1991, pp. 303-311).
  53.  
  54. Approving Authority: Secretary of Commerce.
  55.  
  56. Maintenance  Agency: Computer Systems Laboratory, National
  57. Institute of Standards and Technology.
  58.  
  59.  
  60. Applicability: This standard is applicable to all Federal
  61. departments and agencies for the protection of unclassified
  62. information that is not subject to section 2315 of Title 10, United
  63. States Code, or section 3502(2) of Title 44, United States Code. 
  64. This standard is required for use with the Digital Signature
  65. Standard and whenever a secure hash algorithm is required for
  66. federal applications.  Private and commercial organizations are
  67. encouraged to adopt and use this standard. 
  68.  
  69. Applications: The SHA is appropriate for use with the Digital
  70. Signature Standard, which in turn may be used in electronic mail,
  71. electronic funds transfer, software distribution, data storage, and
  72. other applications which require data integrity assurance and data
  73. origin authentication.  The SHA can also be used whenever it is
  74. necessary to generate a condensed version of a message.
  75.  
  76. Implementations: The SHA may be implemented in software, firmware,
  77. hardware, or any combination thereof.  Only implementations of the
  78. SHA that are validated by NIST will be considered as complying with
  79. this standard.  Information about the requirements for validating
  80. implementations of this standard can be obtained from the National
  81. Institute of Standards and Technology, Computer Systems Laboratory,
  82. Attn: SHS Validation, Gaithersburg, MD 20899.
  83.  
  84. Export Control: Implementations of this standard are subject to
  85. Federal Government export controls as specified in Title 15, Code
  86. of Federal Regulations, Parts 768 through 799.  Exporters are
  87. advised to contact the Department of Commerce, Bureau of Export
  88. Administration for more information.
  89.  
  90. Patents: Implementations of the SHA in this standard may be covered
  91. by U.S. and foreign patents.
  92.  
  93. Implementation Schedule: This standard becomes effective six months
  94. after the publication date of this FIPS PUB.
  95.  
  96. Specifications: Federal Information Processing Standard (FIPS YY)
  97. Secure Hash Standard (affixed).
  98.  
  99. Cross Index:
  100.  
  101.    a. FIPS PUB 46-1, Data Encryption Standard.
  102.  
  103.    b. FIPS PUB 73, Guidelines for Security of Computer            
  104.       Applications.
  105.  
  106.    c. FIPS PUB 140-1, Security Requirements for Cryptographic     
  107.       Modules.
  108.  
  109.    d. FIPS PUB XX, Digital Signature Standard.
  110.  
  111. Qualifications: While it is the intent of this standard to specify
  112. a secure hash algorithm, conformance to this standard does not
  113. assure that a particular implementation is secure.  The responsible
  114. authority in each agency or department shall assure that an overall
  115. implementation provides an acceptable level of security.  This
  116. standard will be reviewed every five years in order to assess its
  117. adequacy.
  118.  
  119. Waiver Procedure: Under certain exceptional circumstances, the
  120. heads of Federal departments and agencies may approve waivers to
  121. Federal Information Processing Standards (FIPS).  The head of such
  122. agency may redelegate such authority only to a senior official
  123. designated pursuant to section 3506(b) of Title 44, United States
  124. Code.  Waiver shall be granted only when:
  125.  
  126.    a. Compliance with a standard would adversely affect the       
  127.       accomplishment of the mission of an operator of a Federal   
  128.       computer system; or
  129.  
  130.    b. Compliance with a standard would cause a major adverse
  131.       financial impact on the operator which is not offset by
  132.       Government-wide savings.
  133.  
  134. Agency heads may act upon a written waiver request containing the
  135. information detailed above.  Agency heads may also act without a
  136. written waiver request when they determine that conditions for
  137. meeting the standard cannot be met.  Agency heads may approve
  138. waivers only by a written decision which explains the basis on
  139. which the agency head made the required finding(s).  A copy of
  140. each decision, with procurement sensitive or classified portions
  141. clearly identified, shall be sent to: National Institute of
  142. Standards and Technology; ATTN: FIPS Waiver Decisions, Technology
  143. Building, Room B-154, Gaithersburg, MD 20899.
  144.  
  145. In addition, notice of each waiver granted and each delegation of
  146. authority to approve waivers shall be sent promptly to the
  147. Committee on Government Operations of the House of Representatives
  148. and the Committee on Government Affairs of the Senate and shall be
  149. published promptly in the Federal Register.
  150.  
  151. When the determination on a waiver applies to the procurement of
  152. equipment and/or services, a notice of the waiver determination
  153. must be published in the Commerce Business Daily as a part of the
  154. notice of solicitation for offers of an acquisition or, if the
  155. waiver determination is made after that notice is published, by
  156. amendment to such notice.
  157.  
  158. A copy of the waiver, any supporting documents, the document
  159. approving the waiver and any accompanying documents, with such
  160. deletions as the agency is authorized and decides to make under 5
  161. United States Code Section 552(b), shall be part of the procurement
  162. documentation and retained by the agency.
  163.  
  164.  
  165.                          Specifications for a
  166.  
  167.  
  168.                        SECURE HASH STANDARD (SHS)
  169.  
  170.  
  171.                             1. INTRODUCTION
  172.  
  173.    The Secure Hash Algorithm (SHA) specified in this standard is
  174. necessary to ensure the security of the Digital Signature Standard. 
  175. When a message of length < 2^64 bits is input, the SHA produces a
  176. 160-bit representation of the message called the message digest. 
  177. The message digest is used during generation of a signature for the
  178. message.  The same message digest should be computed for the
  179. received version of the message, during the process of verifying
  180. the signature.  Any change to the message in transit will, with
  181. very high probability, result in a different message digest, and
  182. the signature will fail to verify.
  183.  
  184.    The SHA is designed to have the following properties: it is
  185. computationally infeasible to recover a message corresponding to a
  186. given message digest, or to find two different messages which
  187. produce the same message digest.
  188.  
  189.                      2. BIT STRINGS AND INTEGERS
  190.  
  191.    The following terminology related to bit strings and integers
  192. will be used:
  193.       
  194.    a. hex digit = 0, 1, ... , 9, a, ... , f.  A hex digit is the  
  195.       representation of a 4-bit string.  Examples: 7 = 0111, a =  
  196.       1010.
  197.  
  198.    b. word = 32-bit string b(31) b(30) ... b(0).  A word may be represented
  199.  
  200.       as a sequence of 8 hex digits.  To convert the latter to    
  201.       a 32-bit string, each hex digit is converted to a 4-bit     
  202.       string as in (a).  Example: 
  203.  
  204.          a103fe23 = 1010 0001 0000 0011 1111 1110 0010 0011.
  205.  
  206.       A word is also the representation of an unsigned integer    
  207.       between 0 and 2^32 - 1, inclusive, with the most significant 
  208.       bit first.  Example: the hex string a103fe23 represents     
  209.       the decimal integer 2701393443.
  210.  
  211.    c. block = 512-bit string.  A block may be represented as a    
  212.       sequence of 16 words.
  213.  
  214.    d. integer: each integer x in the standard will satisfy 0 <=
  215.       x < 2^64.  For the purpose of this standard, "integer" and   
  216.       "unsigned integer" are equivalent.  If an integer x         
  217.       satisfies 0 <= x < 2^32, x may be represented as a word as in     
  218.       (b).  If 2^32 <= x < 2^64, then x = 2^32 y + z where 0 <= y < 2^32 
  219.       and 0 <= z < 2^32.  Hence y and z can be represented as words A and B,
  220.  
  221.       respectively, and x can be represented as the pair of       
  222.       words (A,B).
  223.  
  224.    Suppose 0 <= x < 2^32.  To convert x to a 32-bit string, the
  225. following algorithm may be employed:
  226.  
  227.       y(0) = x;
  228.       for i = 0 to 31 do
  229.         {
  230.         b(i) = 1 if y(i) is odd, b(i) = 0 if y(i) is even;
  231.         y(i+1) = (y(i) - b(i))/2;
  232.         }
  233.  
  234.    Then x has the 32-bit representation b(31) b(30) ... b(0).  Example:
  235.  
  236.       25 = 00000000 00000000 00000000 00011001
  237.          = hex 00000019.
  238.  
  239.    If 2^32 <= x < 2^64, the 2-word representation of x is obtained
  240. similarly. 
  241. Example:
  242.  
  243.       2^35 + 25 = 8 * 2^32 + 25
  244.                = 00000000 00000000 00000000 00001000
  245.                  00000000 00000000 00000000 00011001
  246.                = hex 00000008 00000019.
  247.  
  248.    Conversely, the string b(31) b(30) ... b(0) represents the integer
  249.  
  250.       b(31) * 2^31 + b(30) * 2^30 + ... + b(1) * 2 + b(0).
  251.  
  252.                       3. OPERATIONS ON WORDS
  253.    
  254.    The following logical operators will be applied to words:   
  255.  
  256.       AND    =  bitwise logical and.
  257.  
  258.       OR    =  bitwise logical inclusive-or.
  259.     
  260.       XOR  =  bitwise logical exclusive-or.
  261.  
  262.       ~x   =  bitwise logical complement of x.
  263.  
  264.    Example: 
  265.  
  266.             01101100101110011101001001111011
  267.       XOR   01100101110000010110100110110111
  268.             --------------------------------
  269.         =   00001001011110001011101111001100.
  270.  
  271.    Another operation on words is A + B.  This is defined as
  272. follows: words A and B represent integers x and y, where 0 <= x < 2^32
  273. and 0 <= y < 2^32.  Compute 
  274.  
  275.       z = (x + y) mod 2^32.
  276.  
  277.    Then 0 <= z < 2^32. Convert z to a word, C, and define A + B = C.
  278.  
  279.    Another function on words is S(n,X), where X is a word and n is
  280. an integer with 0 <= n < 32.  This is defined by
  281.  
  282.       S(n,X) = (X << n) OR (X >> 32-n).
  283.  
  284.    In the above, X << n is obtained as follows: discard the
  285. leftmost n bits of X and then pad the result with n zeroes on the
  286. right (the result will still be 32 bits).  X >> m is obtained by
  287. discarding the rightmost m bits of X and then padding the result
  288. with m zeroes on the left.  Thus S(n,X) is equivalent to a circular
  289. shift of X by n positions to the left.
  290.  
  291.                         4. MESSAGE PADDING
  292.  
  293.    The SHA takes bit strings as input.  Thus, for the purpose of
  294. this standard, a message will be considered to be a bit string. 
  295. The length of the message is the number of bits (the empty message
  296. has length 0).  If the number of bits in a message is a multiple of
  297. 8, for compactness we can represent the message in hex.
  298.  
  299.    Suppose a message has length L < 2^64.  Before it is input to the
  300. SHA, the message is padded on the right as follows:
  301.  
  302.    a. "1" is appended.  Example: if the original message is       
  303.       "01010011", this is padded to "010100111".
  304.  
  305.    b. If necessary, "0"s are then appended until the number of bits 
  306.       in the padded message is congruent to 448 modulo 512.       
  307.       Example: suppose the original message is the bit string
  308.          
  309.          01100001 01100010 01100011 01100100 01100101.
  310.  
  311.       After step (a) this gives
  312.  
  313.          01100001 01100010 01100011 01100100 01100101 1.
  314.  
  315.       The number of bits in the above is 41; we pad with 407 "0"s 
  316.       to make the length of the padded message congruent to 448   
  317.       modulo 512.  This gives (in hex)
  318.  
  319.  
  320.          61626364 65800000 00000000 00000000
  321.          00000000 00000000 00000000 00000000
  322.          00000000 00000000 00000000 00000000
  323.          00000000 00000000.
  324.  
  325.       Note that the padding is arranged so that at this point
  326.       the padded message contains 16s + 14 words, for some s >=
  327.       0.
  328.  
  329.    c. Obtain the 2-word representation of L = the number of bits in 
  330.       the original message.  If L < 2^32 then the first word is all 
  331.       zeroes.  Append these two words to the padded message.      
  332.       Example: suppose the original message is as in (b). Then L = 
  333.       40 (note that L is computed before any padding). The two-word 
  334.       representation of 40 is hex 00000000 00000028.  Hence the   
  335.       final padded message is hex
  336.  
  337.          61626364 65800000 00000000 00000000
  338.          00000000 00000000 00000000 00000000
  339.          00000000 00000000 00000000 00000000
  340.          00000000 00000000 00000000 00000028.
  341.  
  342.    The final padded message will contain 16N words for some N > 0.
  343. Example: in (c) above, the final padded message has N = 1. The
  344. final padded message may be regarded as a sequence of N blocks M(1)
  345. , M(2), ... , M(N), where each M(i) contains 16 words and M(1) is leftmost.
  346.  
  347.                          5. FUNCTIONS USED
  348.  
  349.    A sequence of logical functions f(0,x,y,z), ... , f(79,x,y,z) is used in
  350. the
  351. SHA.  Each f operates on three 32-bit words {x,y,z} and produces a 32-bit
  352. word as output.  f(t,x,y,z) is defined as follows: for words x,y,z,
  353.  
  354.       f(t,x,y,z) = (x AND y) OR (~x AND z)             (0  <= t <= 19)
  355.  
  356.       f(t,x,y,z) = x XOR y XOR z                  (20 <= t <= 39)
  357.  
  358.       f(t,x,y,z) = (x AND y) OR (x AND z) OR (y AND z)    (40 <= t <= 59)
  359.  
  360.       f(t,x,y,z) = x XOR y XOR z                  (60 <= t <= 79).
  361.  
  362.                           6. CONSTANTS USED
  363.  
  364.    A sequence of constant words K(0), K(1), ... , K(79) is used in the SHA.
  365. In hex these are given by
  366.  
  367.       K(t) = 5a827999         (0  <= t <= 19)
  368.  
  369.       K(t) = 6ed9eba1         (20 <= t <= 39)
  370.  
  371.       K(t) = 8f1bbcdc         (40 <= t <= 59)
  372.  
  373.       K(t) = ca62c1d6         (60 <= t <= 79).
  374.  
  375.                      7. COMPUTING THE MESSAGE DIGEST
  376.    
  377.    The message digest is computed using the final padded message.
  378. The computation uses two buffers, each consisting of five 32-bit
  379. words, and a sequence of eighty 32-bit words.  The words of the
  380. first 5-word buffer are labeled A,B,C,D,E.  The words of the second
  381. 5-word buffer are labeled h0, h1, h2, h3, h4.  The words of the 80-
  382. word sequence are labeled W(0), W(1), ... , W(79).  A single word buffer
  383. TEMP is also employed.
  384.    
  385.    To generate the message digest, the 16-word blocks M(1), M(2), ...
  386. , M(N) defined in Section 4 are processed in order.  The processing
  387. of each M(i) involves 80 steps.
  388.  
  389.    Before processing any blocks, the {hj} are initialized as
  390. follows: in hex,
  391.  
  392.       h0 = 67452301
  393.  
  394.       h1 = efcdab89
  395.  
  396.       h2 = 98badcfe
  397.  
  398.       h3 = 10325476
  399.  
  400.       h4 = c3d2e1f0.
  401.  
  402.    Now M(1), M(2), ... , M(N) are processed.  To process M(i), we proceed as
  403. follows:
  404.  
  405.    a. Divide M(i) into 16 words W(0), W(1), ... , W(15), where W(0) is the
  406.       leftmost word.
  407.  
  408.    b. For t = 16 to 79 let W(t) = W(t-3) XOR W(t-8) XOR W(t-14) XOR W(t-16).
  409.  
  410.    c. Let A = h0, B = h1, C = h2, D = h3, E = h4.
  411.  
  412.    d. For t = 0 to 79 do
  413.  
  414.         TEMP = S(5,A) + f(t,B,C,D) + E + W(t) + K(t);
  415.  
  416.         E = D;  D = C;  C = S(30,B);  B = A; A = TEMP;
  417.  
  418.    e. Let h0 = h0 + A, h1 = h1 + B, h2 = h2 + C, h3 = h3 + D, h4 = h4 + E.
  419.  
  420.    After processing M(N), the message digest is the 160-bit string
  421. represented by the 5 words
  422.  
  423.       h0 h1 h2 h3 h4.
  424.  
  425.    The above assumes that the sequence W(0), ... , W(79) is implemented
  426. as an array of eighty 32-bit words.  This is efficient from the
  427. standpoint of minimization of execution time, since the addresses
  428. of W(t-3), ... , W(t-16) in step (b) are easily computed.  If space is at
  429. a premium, an alternative is to regard { W(t) } as a circular queue,
  430. which may be implemented using an array of sixteen 32-bit words
  431. W[0], ... W[15].  In this case, in hex let MASK = 0000000f.  Then
  432. processing of M(i) is as follows:
  433.  
  434.    aa. Divide M(i) into 16 words W[0], ... , W[15], where W[0] is the 
  435.        leftmost word.
  436.  
  437.    bb. Let A = h0, B = h1, C = h2, D = h3, E = h4.
  438.  
  439.    cc. For t = 0 to 79 do
  440.         
  441.          s = t AND MASK;
  442.  
  443.          if (t >= 16) W[s] = W[(s + 13) AND MASK] XOR W[(s + 8) AND 
  444.             
  445.             MASK] XOR W[(s + 2) AND MASK] XOR W[s];
  446.  
  447.          TEMP = S(5,A) + f(t,B,C,D) + E + W[s] + K(t);
  448.   
  449.          E = D; D = C; C = S(30,B); B = A; A = TEMP;
  450.  
  451.    dd. Let h0 = h0 + A, h1 = h1 + B, h2 = h2 + C, h3 = h3 + D, h4    
  452.        = h4 + E.
  453.  
  454.    Both (a) - (d) and (aa) - (dd) yield the same message digest.
  455. Although using (aa) - (dd) saves sixty-four 32-bit words of
  456. storage, it is likely to lengthen execution time due to the
  457. increased complexity of the address computations for the { W[t] }
  458. in step (cc).  Other computation methods which give identical
  459. results may be implemented in conformance with the standard.
  460.  
  461.    Examples are given in the appendices.
  462.  
  463.            APPENDIX A. A SAMPLE MESSAGE AND ITS MESSAGE DIGEST
  464.  
  465.    This appendix is for informational purposes only and is not
  466. required to meet the standard.
  467.  
  468.    Let the message be the ASCII binary-coded form of "abc", i.e.
  469.  
  470.       01100001 01100010 01100011.
  471.  
  472.    This message has length L = 24.  In step (a) of Section 4, we
  473. append "1", giving a new length of 25.  In step (b) we append 423
  474. "0"s.  In step (c) we append hex 00000000 00000018, the 2-word
  475. representation of 24.  Thus the final padded message consists of
  476. one block, so that N = 1 in the notation of Section 4.  The single
  477. block has hex words
  478.  
  479. W[ 0] = 61626380
  480. W[ 1] = 00000000
  481. W[ 2] = 00000000
  482. W[ 3] = 00000000
  483. W[ 4] = 00000000
  484. W[ 5] = 00000000
  485. W[ 6] = 00000000
  486. W[ 7] = 00000000
  487. W[ 8] = 00000000
  488. W[ 9] = 00000000
  489. W[10] = 00000000
  490. W[11] = 00000000
  491. W[12] = 00000000
  492. W[13] = 00000000
  493. W[14] = 00000000
  494. W[15] = 00000018
  495.  
  496.    Initial hex values of h:
  497.          
  498.          h0        h1        h2        h3        h4
  499.  
  500.       67452301  efcdab89  98badcfe  10325476  c3d2e1f0
  501.  
  502.    Hex values of A,B,C,D,E after pass t of the "for t = 0 to 79"
  503. loop (step (d) or (cc)) in Section 7:
  504.  
  505.             A        B        C        D        E
  506.  
  507. t =  0:  0116fc33 67452301 7bf36ae2 98badcfe 10325476
  508. t =  1:  8990536d 0116fc33 59d148c0 7bf36ae2 98badcfe
  509. t =  2:  a1390f08 8990536d c045bf0c 59d148c0 7bf36ae2
  510. t =  3:  cdd8e11b a1390f08 626414db c045bf0c 59d148c0
  511. t =  4:  cfd499de cdd8e11b 284e43c2 626414db c045bf0c
  512. t =  5:  3fc7ca40 cfd499de f3763846 284e43c2 626414db
  513. t =  6:  993e30c1 3fc7ca40 b3f52677 f3763846 284e43c2
  514. t =  7:  9e8c07d4 993e30c1 0ff1f290 b3f52677 f3763846
  515. t =  8:  4b6ae328 9e8c07d4 664f8c30 0ff1f290 b3f52677
  516. t =  9:  8351f929 4b6ae328 27a301f5 664f8c30 0ff1f290
  517. t = 10:  fbda9e89 8351f929 12dab8ca 27a301f5 664f8c30
  518. t = 11:  63188fe4 fbda9e89 60d47e4a 12dab8ca 27a301f5
  519. t = 12:  4607b664 63188fe4 7ef6a7a2 60d47e4a 12dab8ca
  520. t = 13:  9128f695 4607b664 18c623f9 7ef6a7a2 60d47e4a
  521. t = 14:  196bee77 9128f695 1181ed99 18c623f9 7ef6a7a2
  522. t = 15:  20bdd62f 196bee77 644a3da5 1181ed99 18c623f9
  523. t = 16:  ed2ff4a3 20bdd62f c65afb9d 644a3da5 1181ed99
  524. t = 17:  565df73c ed2ff4a3 c82f758b c65afb9d 644a3da5
  525. t = 18:  550b1e7f 565df73c fb4bfd28 c82f758b c65afb9d
  526. t = 19:  fe0f9e4b 550b1e7f 15977dcf fb4bfd28 c82f758b
  527. t = 20:  b4d4c943 fe0f9e4b d542c79f 15977dcf fb4bfd28
  528. t = 21:  43993572 b4d4c943 ff83e792 d542c79f 15977dcf
  529. t = 22:  f7106486 43993572 ed353250 ff83e792 d542c79f
  530. t = 23:  775924e6 f7106486 90e64d5c ed353250 ff83e792
  531. t = 24:  45a7ef23 775924e6 bdc41921 90e64d5c ed353250
  532. t = 25:  ccead674 45a7ef23 9dd64939 bdc41921 90e64d5c
  533. t = 26:  02d0c6d1 ccead674 d169fbc8 9dd64939 bdc41921
  534. t = 27:  070c437f 02d0c6d1 333ab59d d169fbc8 9dd64939
  535. t = 28:  301e90be 070c437f 40b431b4 333ab59d d169fbc8
  536. t = 29:  b898c685 301e90be c1c310df 40b431b4 333ab59d
  537. t = 30:  669723e2 b898c685 8c07a42f c1c310df 40b431b4
  538. t = 31:  d9316f96 669723e2 6e2631a1 8c07a42f c1c310df
  539. t = 32:  db81a5c7 d9316f96 99a5c8f8 6e2631a1 8c07a42f
  540. t = 33:  99c8dfb2 db81a5c7 b64c5be5 99a5c8f8 6e2631a1
  541. t = 34:  6be6ae07 99c8dfb2 f6e06971 b64c5be5 99a5c8f8
  542. t = 35:  c01cc62c 6be6ae07 a67237ec f6e06971 b64c5be5
  543. t = 36:  6433fdd0 c01cc62c daf9ab81 a67237ec f6e06971
  544. t = 37:  0a33ccf7 6433fdd0 3007318b daf9ab81 a67237ec
  545. t = 38:  4bf58dc8 0a33ccf7 190cff74 3007318b daf9ab81
  546. t = 39:  ebbd5233 4bf58dc8 c28cf33d 190cff74 3007318b
  547. t = 40:  825a3460 ebbd5233 12fd6372 c28cf33d 190cff74
  548. t = 41:  b62cbb93 825a3460 faef548c 12fd6372 c28cf33d
  549. t = 42:  aa3f9707 b62cbb93 20968d18 faef548c 12fd6372
  550. t = 43:  fe1d0273 aa3f9707 ed8b2ee4 20968d18 faef548c
  551. t = 44:  57ad526b fe1d0273 ea8fe5c1 ed8b2ee4 20968d18
  552. t = 45:  93ebbe3f 57ad526b ff87409c ea8fe5c1 ed8b2ee4
  553. t = 46:  f9adf47b 93ebbe3f d5eb549a ff87409c ea8fe5c1
  554. t = 47:  875586d2 f9adf47b e4faef8f d5eb549a ff87409c
  555. t = 48:  d0a22ffb 875586d2 fe6b7d1e e4faef8f d5eb549a
  556. t = 49:  c12b6426 d0a22ffb a1d561b4 fe6b7d1e e4faef8f
  557. t = 50:  ebc90281 c12b6426 f4288bfe a1d561b4 fe6b7d1e
  558. t = 51:  e7d0ec05 ebc90281 b04ad909 f4288bfe a1d561b4
  559. t = 52:  7cb98e55 e7d0ec05 7af240a0 b04ad909 f4288bfe
  560. t = 53:  0d48dba2 7cb98e55 79f43b01 7af240a0 b04ad909
  561. t = 54:  c2d477bf 0d48dba2 5f2e6395 79f43b01 7af240a0
  562. t = 55:  236bd48d c2d477bf 835236e8 5f2e6395 79f43b01
  563. t = 56:  9b4364d6 236bd48d f0b51def 835236e8 5f2e6395
  564. t = 57:  5b8c33c9 9b4364d6 48daf523 f0b51def 835236e8
  565. t = 58:  be2a4656 5b8c33c9 a6d0d935 48daf523 f0b51def
  566. t = 59:  8ff296db be2a4656 56e30cf2 a6d0d935 48daf523
  567. t = 60:  c10c8993 8ff296db af8a9195 56e30cf2 a6d0d935
  568. t = 61:  6ac23cbf c10c8993 e3fca5b6 af8a9195 56e30cf2
  569. t = 62:  0708247d 6ac23cbf f0432264 e3fca5b6 af8a9195
  570. t = 63:  35d201f8 0708247d dab08f2f f0432264 e3fca5b6
  571. t = 64:  969b2fc8 35d201f8 41c2091f dab08f2f f0432264
  572. t = 65:  3cac6514 969b2fc8 0d74807e 41c2091f dab08f2f
  573. t = 66:  14cd9a35 3cac6514 25a6cbf2 0d74807e 41c2091f
  574. t = 67:  ba564047 14cd9a35 0f2b1945 25a6cbf2 0d74807e
  575. t = 68:  c241f74d ba564047 4533668d 0f2b1945 25a6cbf2
  576. t = 69:  2896b70f c241f74d ee959011 4533668d 0f2b1945
  577. t = 70:  564bbed1 2896b70f 70907dd3 ee959011 4533668d
  578. t = 71:  8fa15d5a 564bbed1 ca25adc3 70907dd3 ee959011
  579. t = 72:  9a226c11 8fa15d5a 5592efb4 ca25adc3 70907dd3
  580. t = 73:  f0b94489 9a226c11 a3e85756 5592efb4 ca25adc3
  581. t = 74:  1809d5e2 f0b94489 66889b04 a3e85756 5592efb4
  582. t = 75:  b86c5a40 1809d5e2 7c2e5122 66889b04 a3e85756
  583. t = 76:  dfe7e487 b86c5a40 86027578 7c2e5122 66889b04
  584. t = 77:  70286c07 dfe7e487 2e1b1690 86027578 7c2e5122
  585. t = 78:  24ff7ed5 70286c07 f7f9f921 2e1b1690 86027578
  586. t = 79:  9a1f95a8 24ff7ed5 dc0a1b01 f7f9f921 2e1b1690
  587.  
  588.    After processing, values of h:
  589.  
  590.          h0        h1        h2        h3        h4
  591.  
  592.       0164b8a9  14cd2a5e  74c4f7ff   082c4d97  f1edf880
  593.  
  594.    Message digest =  0164b8a9 14cd2a5e 74c4f7ff 082c4d97 f1edf880